| GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
| Line | Branch | Exec | Source |
1 |
#include <string> |
||
2 |
#include <functional> |
||
3 |
#include <type_traits> |
||
4 |
|||
5 |
#include "gtest/gtest.h" |
||
6 |
|||
7 |
#include "zserio/ArrayTraits.h" |
||
8 |
#include "zserio/BitStreamReader.h" |
||
9 |
#include "zserio/BitStreamWriter.h" |
||
10 |
#include "zserio/BitSizeOfCalculator.h" |
||
11 |
#include "zserio/Reflectable.h" |
||
12 |
#include "zserio/Vector.h" |
||
13 |
|||
14 |
#include "test_object/std_allocator/ReflectableBitmask.h" |
||
15 |
#include "test_object/std_allocator/ReflectableEnum.h" |
||
16 |
#include "test_object/std_allocator/ReflectableNested.h" |
||
17 |
#include "test_object/std_allocator/ReflectableObject.h" |
||
18 |
|||
19 |
using test_object::std_allocator::ReflectableBitmask; |
||
20 |
using test_object::std_allocator::ReflectableEnum; |
||
21 |
using test_object::std_allocator::ReflectableNested; |
||
22 |
using test_object::std_allocator::ReflectableObject; |
||
23 |
|||
24 |
using namespace std::placeholders; |
||
25 |
|||
26 |
namespace zserio |
||
27 |
{ |
||
28 |
|||
29 |
namespace |
||
30 |
{ |
||
31 |
|||
32 |
5 |
ReflectableObject createInitializedReflectableObject(const string<>& stringField, |
|
33 |
uint32_t reflectableNestedValue) |
||
34 |
{ |
||
35 |
✓✗ | 5 |
ReflectableObject reflectableObject(stringField, ReflectableNested{reflectableNestedValue}); |
36 |
✓✗ | 5 |
reflectableObject.initializeChildren(); |
37 |
5 |
return reflectableObject; |
|
38 |
} |
||
39 |
|||
40 |
} // namespace |
||
41 |
|||
42 |
namespace detail |
||
43 |
{ |
||
44 |
|||
45 |
template <typename FUNC> |
||
46 |
struct return_type; |
||
47 |
|||
48 |
template <typename R, typename CLASS, typename... ARGS> |
||
49 |
struct return_type<R (CLASS::*) (ARGS...) const> |
||
50 |
{ |
||
51 |
using type = R; |
||
52 |
}; |
||
53 |
|||
54 |
} // namespace |
||
55 |
|||
56 |
✗✓ | 220 |
class ReflectableTest : public ::testing::Test |
57 |
{ |
||
58 |
protected: |
||
59 |
template <typename RAW_ARRAY> |
||
60 |
40 |
void checkArrayAnyValue(const RAW_ARRAY& rawArray, const IReflectableConstPtr& reflectable) |
|
61 |
{ |
||
62 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
40 |
ASSERT_EQ(rawArray, |
63 |
reflectable->getAnyValue().template get<std::reference_wrapper<const RAW_ARRAY>>().get()); |
||
64 |
} |
||
65 |
|||
66 |
template <typename RAW_ARRAY> |
||
67 |
31 |
void checkArrayAnyValue(const RAW_ARRAY& rawArray, const IReflectablePtr& reflectable) |
|
68 |
{ |
||
69 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
31 |
ASSERT_EQ(rawArray, |
70 |
reflectable->getAnyValue().template get<std::reference_wrapper<RAW_ARRAY>>().get()); |
||
71 |
} |
||
72 |
|||
73 |
template <typename RAW_ARRAY, typename REFLECTABLE_PTR, typename ELEMENT_CHECKER> |
||
74 |
71 |
void checkArray(const RAW_ARRAY& rawArray, const REFLECTABLE_PTR& reflectable, |
|
75 |
const ELEMENT_CHECKER& elementChecker) |
||
76 |
{ |
||
77 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
71 |
ASSERT_TRUE(reflectable->isArray()); |
78 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
71 |
ASSERT_EQ(rawArray.size(), reflectable->size()); |
79 |
✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓ |
330 |
for (size_t i = 0; i < rawArray.size(); ++i) |
80 |
{ |
||
81 |
✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓ |
259 |
if (i % 2 == 0) |
82 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
141 |
elementChecker(rawArray[i], reflectable->at(i)); |
83 |
else |
||
84 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗ |
118 |
elementChecker(rawArray[i], (*reflectable)[i]); |
85 |
} |
||
86 |
|||
87 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->at(rawArray.size()), CppRuntimeException); |
88 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW((*reflectable)[rawArray.size()], CppRuntimeException); |
89 |
|||
90 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗ |
71 |
checkArrayAnyValue(rawArray, reflectable); |
91 |
|||
92 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getBool(), CppRuntimeException); |
93 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
94 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
95 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
96 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
97 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
98 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
99 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
100 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
101 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
102 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
103 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
104 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
105 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
106 |
|||
107 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
108 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
109 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
110 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
142 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
111 |
|||
112 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
142 |
ASSERT_THROW(reflectable->bitSizeOf(0), CppRuntimeException); |
113 |
|||
114 |
✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗ |
142 |
BitBuffer bitBuffer(0); |
115 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗ |
71 |
BitStreamWriter writer(bitBuffer); |
116 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
142 |
ASSERT_THROW(reflectable->write(writer), CppRuntimeException); |
117 |
|||
118 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
71 |
checkNonCompound(reflectable); |
119 |
} |
||
120 |
|||
121 |
template <typename T, typename REFLECTABLE_PTR, typename READ_FUNC> |
||
122 |
308 |
void checkWriteRead(T value, const REFLECTABLE_PTR& reflectable, const READ_FUNC& readFunc, |
|
123 |
size_t bitBufferSize) |
||
124 |
{ |
||
125 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
616 |
BitBuffer bitBuffer(bitBufferSize); |
126 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
308 |
BitStreamWriter writer(bitBuffer); |
127 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
308 |
reflectable->write(writer); |
128 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
308 |
const size_t bitSizeOfValue = reflectable->bitSizeOf(); |
129 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
308 |
ASSERT_EQ(bitSizeOfValue, writer.getBitPosition()); |
130 |
|||
131 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
308 |
BitStreamReader reader(bitBuffer); |
132 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
308 |
ASSERT_EQ(value, readFunc(reader)); |
133 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ |
308 |
ASSERT_EQ(bitSizeOfValue, reader.getBitPosition()); |
134 |
} |
||
135 |
|||
136 |
308 |
void checkNonArray(const IReflectableConstPtr& reflectable) |
|
137 |
{ |
||
138 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗ |
308 |
ASSERT_FALSE(reflectable->isArray()); |
139 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
616 |
ASSERT_THROW(reflectable->size(), CppRuntimeException); |
140 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
616 |
ASSERT_THROW(reflectable->at(0), CppRuntimeException); |
141 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
616 |
ASSERT_THROW((*reflectable)[0], CppRuntimeException); |
142 |
} |
||
143 |
|||
144 |
125 |
void checkNonArray(const IReflectablePtr& reflectable) |
|
145 |
{ |
||
146 |
✓✗✓✗ ✗ |
125 |
checkNonArray(static_cast<IReflectableConstPtr>(reflectable)); |
147 |
|||
148 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
250 |
ASSERT_THROW(reflectable->at(0), CppRuntimeException); |
149 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
250 |
ASSERT_THROW((*reflectable)[0], CppRuntimeException); |
150 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
250 |
ASSERT_THROW(reflectable->resize(1), CppRuntimeException); |
151 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
250 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException); |
152 |
} |
||
153 |
|||
154 |
template <typename REFLECTABLE_PTR> |
||
155 |
368 |
void checkNonCompoundConstMethods(const REFLECTABLE_PTR& reflectable) |
|
156 |
{ |
||
157 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
736 |
ASSERT_THROW(reflectable->getField("field"), CppRuntimeException); |
158 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
736 |
ASSERT_THROW(reflectable->getParameter("parameter"), CppRuntimeException); |
159 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
736 |
ASSERT_THROW(reflectable->callFunction("function"), CppRuntimeException); |
160 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
736 |
ASSERT_THROW(reflectable->getChoice(), CppRuntimeException); |
161 |
|||
162 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
368 |
ASSERT_EQ(nullptr, reflectable->find("some.field")); |
163 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
368 |
ASSERT_EQ(nullptr, (*reflectable)["some.field"]); |
164 |
} |
||
165 |
|||
166 |
153 |
void checkNonCompound(const IReflectablePtr& reflectable) |
|
167 |
{ |
||
168 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
306 |
ASSERT_THROW(reflectable->initializeChildren(), CppRuntimeException); |
169 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
306 |
ASSERT_THROW(reflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException); |
170 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
306 |
ASSERT_THROW(reflectable->setField("field", AnyHolder<>{}), CppRuntimeException); |
171 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
306 |
ASSERT_THROW(reflectable->createField("field"), CppRuntimeException); |
172 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
306 |
ASSERT_THROW(reflectable->initializeOffsets(), CppRuntimeException); |
173 |
|||
174 |
✓✗✗ | 153 |
checkNonCompoundConstMethods(reflectable); |
175 |
} |
||
176 |
|||
177 |
215 |
void checkNonCompound(const IReflectableConstPtr& reflectable) |
|
178 |
{ |
||
179 |
215 |
checkNonCompoundConstMethods(reflectable); |
|
180 |
215 |
} |
|
181 |
|||
182 |
template <typename T, typename REFLECTABLE_PTR, typename GETTER, |
||
183 |
typename std::enable_if< |
||
184 |
std::is_same<T, typename detail::return_type<GETTER>::type>::value, int>::type = 0> |
||
185 |
283 |
void checkCppTypeGetter(T value, const REFLECTABLE_PTR& reflectable, const GETTER& getter, |
|
186 |
const char* testName, const char* getterName) |
||
187 |
{ |
||
188 |
✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ |
283 |
ASSERT_EQ(value, ((*reflectable).*getter)()) << testName << " : " << getterName; |
189 |
} |
||
190 |
|||
191 |
template <typename T, typename REFLECTABLE_PTR, typename GETTER, |
||
192 |
typename std::enable_if< |
||
193 |
!std::is_same<T, typename detail::return_type<GETTER>::type>::value, int>::type = 0> |
||
194 |
3861 |
void checkCppTypeGetter(T, const REFLECTABLE_PTR& reflectable, const GETTER& getter, |
|
195 |
const char* testName, const char* getterName) |
||
196 |
{ |
||
197 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
3861 |
ASSERT_THROW(((*reflectable).*getter)(), CppRuntimeException) << testName << " : " << getterName; |
198 |
} |
||
199 |
|||
200 |
template <typename REFLECTABLE_PTR, typename GETTER, |
||
201 |
typename std::enable_if<std::is_same<Span<const uint8_t>, |
||
202 |
typename detail::return_type<GETTER>::type>::value, int>::type = 0> |
||
203 |
7 |
void checkCppTypeGetter(Span<const uint8_t> value, const REFLECTABLE_PTR& reflectable, const GETTER& getter, |
|
204 |
const char* testName, const char* getterName) |
||
205 |
{ |
||
206 |
✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ |
7 |
ASSERT_EQ(value.size(), ((*reflectable).*getter)().size()) << testName << " : " << getterName; |
207 |
✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ |
7 |
ASSERT_EQ(value.data(), ((*reflectable).*getter)().data()) << testName << " : " << getterName; |
208 |
} |
||
209 |
|||
210 |
template <typename REFLECTABLE_PTR, typename GETTER, |
||
211 |
typename std::enable_if<std::is_same<const BitBuffer&, |
||
212 |
typename detail::return_type<GETTER>::type>::value, int>::type = 0> |
||
213 |
7 |
void checkCppTypeGetter(const BitBuffer& value, const REFLECTABLE_PTR& reflectable, const GETTER& getter, |
|
214 |
const char* testName, const char* getterName) |
||
215 |
{ |
||
216 |
✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ |
7 |
ASSERT_EQ(value, ((*reflectable).*getter)()) << testName << " : " << getterName; |
217 |
} |
||
218 |
|||
219 |
template <typename T, typename REFLECTABLE_PTR> |
||
220 |
297 |
void checkCppTypeGetters(T value, const REFLECTABLE_PTR& reflectable, const char* testName) |
|
221 |
{ |
||
222 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getBool, testName, "getBool"); |
223 |
|||
224 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getInt8, testName, "getInt8"); |
225 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getInt16, testName, "getInt16"); |
226 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getInt32, testName, "getInt32"); |
227 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getInt64, testName, "getInt64"); |
228 |
|||
229 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getUInt8, testName, "getUInt8"); |
230 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getUInt16, testName, "getUInt16"); |
231 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getUInt32, testName, "getUInt32"); |
232 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getUInt64, testName, "getUInt64"); |
233 |
|||
234 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getFloat, testName, "getFloat"); |
235 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getDouble, testName, "getDouble"); |
236 |
|||
237 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getBytes, testName, "getBytes"); |
238 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getStringView, testName, "getStringView"); |
239 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
297 |
checkCppTypeGetter(value, reflectable, &IReflectable::getBitBuffer, testName, "getBitBuffer"); |
240 |
297 |
} |
|
241 |
|||
242 |
template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
||
243 |
19 |
void checkFloatingPoint(T value, const REFLECTABLE_PTR& reflectable, |
|
244 |
const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8) |
||
245 |
{ |
||
246 |
✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
19 |
ASSERT_DOUBLE_EQ(value, ((*reflectable).*getter)()); |
247 |
|||
248 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ |
19 |
ASSERT_DOUBLE_EQ(value, reflectable->toDouble()); |
249 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
38 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
250 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
38 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
251 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
38 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); // NOT IMPLEMENTED! |
252 |
|||
253 |
19 |
checkCppTypeGetters(value, reflectable, "checkFloatingPoint"); |
|
254 |
|||
255 |
19 |
checkNonCompound(reflectable); |
|
256 |
19 |
checkNonArray(reflectable); |
|
257 |
|||
258 |
19 |
checkWriteRead(value, reflectable, readFunc, bitSize); |
|
259 |
} |
||
260 |
|||
261 |
template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
||
262 |
232 |
void checkIntegral(T value, const REFLECTABLE_PTR& reflectable, |
|
263 |
const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize, const char* testName) |
||
264 |
{ |
||
265 |
✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
232 |
ASSERT_EQ(value, ((*reflectable).*getter)()); |
266 |
|||
267 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
232 |
ASSERT_EQ(value, reflectable->getAnyValue().template get<T>()); |
268 |
|||
269 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
232 |
ASSERT_DOUBLE_EQ(static_cast<double>(value), reflectable->toDouble()); |
270 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
232 |
ASSERT_EQ(zserio::toString(value), reflectable->toString()); |
271 |
|||
272 |
232 |
checkCppTypeGetters(value, reflectable, testName); |
|
273 |
|||
274 |
232 |
checkNonCompound(reflectable); |
|
275 |
232 |
checkNonArray(reflectable); |
|
276 |
|||
277 |
232 |
checkWriteRead(value, reflectable, readFunc, bitSize); |
|
278 |
} |
||
279 |
|||
280 |
template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
||
281 |
114 |
void checkSignedIntegral(T value, const REFLECTABLE_PTR& reflectable, |
|
282 |
const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8) |
||
283 |
{ |
||
284 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗ |
114 |
ASSERT_EQ(value, reflectable->toInt()); |
285 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
228 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
286 |
|||
287 |
114 |
checkIntegral(value, reflectable, getter, readFunc, bitSize, "checkSignedIntegral"); |
|
288 |
} |
||
289 |
|||
290 |
template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
||
291 |
118 |
void checkUnsignedIntegral(T value, const REFLECTABLE_PTR& reflectable, |
|
292 |
const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8) |
||
293 |
{ |
||
294 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗ |
118 |
ASSERT_EQ(value, reflectable->toUInt()); |
295 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
236 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
296 |
|||
297 |
118 |
checkIntegral(value, reflectable, getter, readFunc, bitSize, "checkUnsignedIntegral"); |
|
298 |
} |
||
299 |
|||
300 |
template <typename REFLECTABLE_PTR> |
||
301 |
11 |
void checkString(StringView value, const REFLECTABLE_PTR& reflectable) |
|
302 |
{ |
||
303 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(value, reflectable->getAnyValue().template get<StringView>()); |
304 |
|||
305 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
11 |
ASSERT_EQ(toString(value), reflectable->toString()); |
306 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
307 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
308 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
22 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
309 |
|||
310 |
11 |
checkCppTypeGetters(value, reflectable, "checkString"); |
|
311 |
|||
312 |
11 |
checkNonCompound(reflectable); |
|
313 |
11 |
checkNonArray(reflectable); |
|
314 |
|||
315 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
11 |
checkWriteRead(toString(value), reflectable, |
316 |
std::bind(&BitStreamReader::readString<>, _1, std::allocator<uint8_t>()), |
||
317 |
11 |
bitSizeOfVarSize(convertSizeToUInt32(value.size())) + value.size() * 8); |
|
318 |
} |
||
319 |
|||
320 |
template <typename REFLECTABLE_PTR> |
||
321 |
7 |
void checkBitBuffer(const BitBuffer& value, const REFLECTABLE_PTR& reflectable) |
|
322 |
{ |
||
323 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
7 |
ASSERT_EQ(value, reflectable->getAnyValue(). |
324 |
template get<std::reference_wrapper<const BitBuffer>>().get()); |
||
325 |
|||
326 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
14 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
327 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
14 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
328 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
14 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
329 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
14 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
330 |
|||
331 |
✓✗✓✗ |
7 |
checkCppTypeGetters(value, reflectable, "checkBitBuffer"); |
332 |
|||
333 |
7 |
checkNonCompound(reflectable); |
|
334 |
7 |
checkNonArray(reflectable); |
|
335 |
|||
336 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
7 |
checkWriteRead(value, reflectable, |
337 |
std::bind(&BitStreamReader::readBitBuffer<>, _1, std::allocator<uint8_t>()), |
||
338 |
7 |
bitSizeOfVarSize(convertSizeToUInt32(value.getBitSize())) + value.getBitSize()); |
|
339 |
} |
||
340 |
|||
341 |
template <typename REFLECTABLE_PTR> |
||
342 |
7 |
void checkBytes(const std::vector<uint8_t>& value, const REFLECTABLE_PTR& reflectable) |
|
343 |
{ |
||
344 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
7 |
ASSERT_EQ(value.data(), reflectable->getBytes().data()); |
345 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
7 |
ASSERT_EQ(value.size(), reflectable->getBytes().size()); |
346 |
✓✗✓✗ ✓✗✓✗ |
7 |
auto anyValue = reflectable->getAnyValue().template get<Span<const uint8_t>>(); |
347 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
7 |
ASSERT_EQ(value.data(), anyValue.data()); |
348 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
7 |
ASSERT_EQ(value.size(), anyValue.size()); |
349 |
|||
350 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
14 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
351 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
14 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
352 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
14 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
353 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
14 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
354 |
|||
355 |
✓✗✓✗ ✓✗✓✗ |
7 |
checkCppTypeGetters(Span<const uint8_t>(value), reflectable, "checkBytes"); |
356 |
|||
357 |
✓✗✓✗ |
7 |
checkNonCompound(reflectable); |
358 |
✓✗✓✗ |
7 |
checkNonArray(reflectable); |
359 |
|||
360 |
7 |
const size_t bitSize = value.size() * 8; |
|
361 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
7 |
checkWriteRead(value, reflectable, |
362 |
std::bind(&BitStreamReader::readBytes<>, _1, std::allocator<uint8_t>()), |
||
363 |
✓✗✓✗ ✓✗✓✗ |
7 |
bitSizeOfVarSize(convertSizeToUInt32(bitSize)) + bitSize); |
364 |
} |
||
365 |
|||
366 |
template <typename REFLECTABLE_PTR> |
||
367 |
11 |
void checkBitmask(ReflectableBitmask bitmask, const REFLECTABLE_PTR& reflectable) |
|
368 |
{ |
||
369 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(bitmask.getValue(), reflectable->getUInt8()); |
370 |
|||
371 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(bitmask, reflectable->getAnyValue().template get<ReflectableBitmask>()); |
372 |
|||
373 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(bitmask.getValue(), reflectable->toUInt()); |
374 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(bitmask.getValue(), reflectable->toDouble()); |
375 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
11 |
ASSERT_EQ(bitmask.toString(), reflectable->toString()); |
376 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
22 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
377 |
|||
378 |
11 |
checkCppTypeGetters(bitmask.getValue(), reflectable, "checkBitmask"); |
|
379 |
|||
380 |
11 |
checkNonCompound(reflectable); |
|
381 |
11 |
checkNonArray(reflectable); |
|
382 |
|||
383 |
✓✗✓✗ |
11 |
checkWriteRead(bitmask, reflectable, |
384 |
11 |
[](BitStreamReader& reader) { |
|
385 |
return ReflectableBitmask(reader); |
||
386 |
11 |
}, 8 |
|
387 |
); |
||
388 |
} |
||
389 |
|||
390 |
template <typename REFLECTABLE_PTR> |
||
391 |
10 |
void checkEnum(ReflectableEnum enumeration, const REFLECTABLE_PTR& reflectable) |
|
392 |
{ |
||
393 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
10 |
ASSERT_EQ(enumToValue(enumeration), reflectable->getInt8()); |
394 |
|||
395 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
10 |
ASSERT_EQ(enumeration, reflectable->getAnyValue().template get<ReflectableEnum>()); |
396 |
|||
397 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
10 |
ASSERT_EQ(enumToValue(enumeration), reflectable->toInt()); |
398 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
10 |
ASSERT_EQ(enumToValue(enumeration), reflectable->toDouble()); |
399 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
10 |
ASSERT_EQ(enumToString(enumeration), reflectable->toString()); |
400 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
20 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
401 |
|||
402 |
10 |
checkCppTypeGetters(enumToValue(enumeration), reflectable, "checkEnum"); |
|
403 |
|||
404 |
10 |
checkNonCompound(reflectable); |
|
405 |
10 |
checkNonArray(reflectable); |
|
406 |
|||
407 |
✓✗✓✗ |
10 |
checkWriteRead(enumeration, reflectable, |
408 |
10 |
[](BitStreamReader& reader) { |
|
409 |
return zserio::read<ReflectableEnum>(reader); |
||
410 |
10 |
}, 8 |
|
411 |
); |
||
412 |
} |
||
413 |
|||
414 |
8 |
void checkCompoundAnyValue(const ReflectableObject& reflectableObject, |
|
415 |
const IReflectableConstPtr& reflectable) |
||
416 |
{ |
||
417 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
8 |
ASSERT_EQ(reflectableObject, |
418 |
reflectable->getAnyValue(). |
||
419 |
template get<std::reference_wrapper<const ReflectableObject>>().get()); |
||
420 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
8 |
ASSERT_EQ(reflectableObject.getReflectableNested(), |
421 |
reflectable->getField("reflectableNested")->getAnyValue(). |
||
422 |
template get<std::reference_wrapper<const ReflectableNested>>().get()); |
||
423 |
} |
||
424 |
|||
425 |
3 |
void checkCompoundAnyValue(const ReflectableObject& reflectableObject, |
|
426 |
const IReflectablePtr& reflectable) |
||
427 |
{ |
||
428 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(reflectableObject, |
429 |
reflectable->getAnyValue(). |
||
430 |
template get<std::reference_wrapper<ReflectableObject>>().get()); |
||
431 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(reflectableObject.getReflectableNested(), |
432 |
reflectable->getField("reflectableNested")->getAnyValue(). |
||
433 |
template get<std::reference_wrapper<ReflectableNested>>().get()); |
||
434 |
} |
||
435 |
|||
436 |
template <typename REFLECTABLE_PTR> |
||
437 |
11 |
void checkCompoundConstMethods(const ReflectableObject& reflectableObject, |
|
438 |
const REFLECTABLE_PTR& reflectable) |
||
439 |
{ |
||
440 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_TRUE(TypeInfoUtil::isCompound(reflectable->getTypeInfo().getSchemaType())); |
441 |
|||
442 |
// field getter |
||
443 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
444 |
reflectable->getField("reflectableNested")->getField("value")->getUInt32()); |
||
445 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
22 |
ASSERT_THROW(reflectable->getField("nonexistent"), CppRuntimeException); |
446 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
22 |
ASSERT_THROW(reflectable->getField("reflectableNested")->getField("nonexistent"), CppRuntimeException); |
447 |
|||
448 |
// find field |
||
449 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
450 |
reflectable->find("reflectableNested.value")->toUInt()); |
||
451 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
452 |
(*reflectable)["reflectableNested.value"]->toDouble()); |
||
453 |
|||
454 |
// find parameter |
||
455 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
11 |
ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam")); |
456 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(13, (*reflectable)["reflectableNested.dummyParam"]->getInt32()); |
457 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
11 |
ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam")); |
458 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(reflectableObject.getStringField(), |
459 |
(*reflectable)["reflectableNested.stringParam"]->toString()); |
||
460 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
22 |
ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("nonexistent"), |
461 |
CppRuntimeException); |
||
462 |
|||
463 |
// find function |
||
464 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
465 |
(*reflectable)["reflectableNested.getValue"]->getUInt32()); |
||
466 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
22 |
ASSERT_THROW(reflectable->getField("reflectableNested")->callFunction("nonexistent"), |
467 |
CppRuntimeException); |
||
468 |
|||
469 |
// find failed |
||
470 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("reflectableNested.nonexistent")); |
471 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("nonexistent")); |
472 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("reflectableNested.value.nonexistent")); |
473 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("reflectableNested.dummyParam.nonexistent")); |
474 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("reflectableNested.getValue.nonexistent")); |
475 |
// find failed because the underlying code throws |
||
476 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("reflectableNested.throwingFunction.nonexistent")); |
477 |
|||
478 |
11 |
checkCompoundAnyValue(reflectableObject, reflectable); |
|
479 |
|||
480 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getBool(), CppRuntimeException); |
481 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
482 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
483 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
484 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
485 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
486 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
487 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
488 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
489 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
490 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
491 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
492 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
493 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
494 |
|||
495 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
496 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
497 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
498 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
22 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
499 |
|||
500 |
11 |
checkNonArray(reflectable); |
|
501 |
|||
502 |
✓✗✓✗ ✓✗✓✗ |
11 |
checkWriteRead(reflectableObject, reflectable, |
503 |
11 |
[](BitStreamReader& reader) { |
|
504 |
return ReflectableObject(reader); |
||
505 |
✓✗✓✗ |
11 |
}, reflectableObject.bitSizeOf() |
506 |
); |
||
507 |
} |
||
508 |
|||
509 |
5 |
void checkCompound(const ReflectableObject& reflectableObject, const IReflectableConstPtr& reflectable) |
|
510 |
{ |
||
511 |
5 |
checkCompoundConstMethods(reflectableObject, reflectable); |
|
512 |
5 |
} |
|
513 |
|||
514 |
3 |
void checkCompound(const ReflectableObject& reflectableObject, const IReflectablePtr& reflectable) |
|
515 |
{ |
||
516 |
3 |
checkCompoundConstMethods(reflectableObject, reflectable); |
|
517 |
✓✗ | 3 |
checkCompoundConstMethods(reflectableObject, static_cast<IReflectableConstPtr>(reflectable)); |
518 |
|||
519 |
// setter |
||
520 |
✓✗✓✗ ✓✗ |
3 |
reflectable->getField("reflectableNested")->setField("value", AnyHolder<>(static_cast<uint32_t>(11))); |
521 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(11, reflectableObject.getReflectableNested().getValue()); |
522 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
6 |
ASSERT_THROW(reflectable->setField("nonexistent", AnyHolder<>()), CppRuntimeException); |
523 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
6 |
ASSERT_THROW(reflectable->find("reflectableNested")->setField("nonexistent", AnyHolder<>()), |
524 |
CppRuntimeException); |
||
525 |
|||
526 |
// any value |
||
527 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(reflectableObject.getReflectableNested(), reflectable->find("reflectableNested")-> |
528 |
getAnyValue().template get<std::reference_wrapper<ReflectableNested>>().get()); |
||
529 |
|||
530 |
✓✗ | 3 |
reflectable->createField("reflectableNested"); |
531 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(uint32_t(), reflectableObject.getReflectableNested().getValue()); |
532 |
|||
533 |
✓✗✓✗ |
3 |
reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42})); |
534 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(42, reflectableObject.getReflectableNested().getValue()); |
535 |
3 |
reflectable->initializeChildren(); // keep the reflectable initialized for following tests |
|
536 |
} |
||
537 |
}; |
||
538 |
|||
539 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, boolReflectable) |
540 |
{ |
||
541 |
1 |
const bool value = true; |
|
542 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getBool(value); |
543 |
3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getBool, |
|
544 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBool, _1)); |
545 |
1 |
} |
|
546 |
|||
547 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int8Reflectable) |
548 |
{ |
||
549 |
1 |
const int8_t value = -12; |
|
550 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt8(value); |
551 |
3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt8, |
|
552 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, 8)); |
553 |
1 |
} |
|
554 |
|||
555 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int16Reflectable) |
556 |
{ |
||
557 |
1 |
const int16_t value = -1234; |
|
558 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt16(value); |
559 |
3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
|
560 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, 16)); |
561 |
1 |
} |
|
562 |
|||
563 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int32Reflectable) |
564 |
{ |
||
565 |
1 |
const int32_t value = -123456; |
|
566 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt32(value); |
567 |
3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
|
568 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, 32)); |
569 |
1 |
} |
|
570 |
|||
571 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int64Reflectable) |
572 |
{ |
||
573 |
1 |
const int64_t value = -1234567890; |
|
574 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt64(value); |
575 |
3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
|
576 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits64, _1, 64)); |
577 |
1 |
} |
|
578 |
|||
579 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint8Reflectable) |
580 |
{ |
||
581 |
1 |
const uint8_t value = 0xFF; |
|
582 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt8(value); |
583 |
3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8, |
|
584 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, 8)); |
585 |
1 |
} |
|
586 |
|||
587 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint16Reflectable) |
588 |
{ |
||
589 |
1 |
const uint16_t value = 0xFFFF; |
|
590 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt16(value); |
591 |
3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
|
592 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, 16)); |
593 |
1 |
} |
|
594 |
|||
595 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint32Reflectable) |
596 |
{ |
||
597 |
1 |
const uint32_t value = 0xFFFFFFFF; |
|
598 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt32(value); |
599 |
3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
|
600 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, 32)); |
601 |
1 |
} |
|
602 |
|||
603 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint64Reflectable) |
604 |
{ |
||
605 |
1 |
const uint64_t value = 0xFFFFFFFFFFFF; |
|
606 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt64(value); |
607 |
3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
|
608 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits64, _1, 64)); |
609 |
1 |
} |
|
610 |
|||
611 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedSignedBitField5) // mapped to int8_t |
612 |
{ |
||
613 |
1 |
const uint8_t numBits = 5; |
|
614 |
1 |
const int8_t value = 15; |
|
615 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits); |
616 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt8, |
|
617 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
618 |
|||
619 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 10), CppRuntimeException); |
620 |
} |
||
621 |
|||
622 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedSignedBitField15) // mapped to int16_t |
623 |
{ |
||
624 |
1 |
const uint8_t numBits = 15; |
|
625 |
1 |
const int16_t value = -15; |
|
626 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits); |
627 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
|
628 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
629 |
|||
630 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 5), CppRuntimeException); |
631 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 17), CppRuntimeException); |
632 |
} |
||
633 |
|||
634 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedSignedBitField31) // mapped to int32_t |
635 |
{ |
||
636 |
1 |
const uint8_t numBits = 31; |
|
637 |
1 |
const int32_t value = -12345678; |
|
638 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits); |
639 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
|
640 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
641 |
|||
642 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 16), CppRuntimeException); |
643 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 33), CppRuntimeException); |
644 |
} |
||
645 |
|||
646 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedSignedBitField60) // mapped to int64_t |
647 |
{ |
||
648 |
1 |
const uint8_t numBits = 60; |
|
649 |
1 |
const int64_t value = 1234567890; |
|
650 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits); |
651 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
|
652 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits); |
653 |
|||
654 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 31), CppRuntimeException); |
655 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 65), CppRuntimeException); |
656 |
} |
||
657 |
|||
658 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedUnsignedBitField7) // mapped to uint8_t |
659 |
{ |
||
660 |
1 |
const uint8_t numBits = 7; |
|
661 |
1 |
const uint8_t value = 0x2F; |
|
662 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits); |
663 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8, |
|
664 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
665 |
|||
666 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 9), CppRuntimeException); |
667 |
} |
||
668 |
|||
669 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedUnsignedBitField9) // mapped to uint16_t |
670 |
{ |
||
671 |
1 |
const uint8_t numBits = 9; |
|
672 |
1 |
const uint16_t value = 0x1FF; |
|
673 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits); |
674 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
|
675 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
676 |
|||
677 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 8), CppRuntimeException); |
678 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 17), CppRuntimeException); |
679 |
} |
||
680 |
|||
681 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedUnsignedBitField31) // mapped to uint32_t |
682 |
{ |
||
683 |
1 |
const uint8_t numBits = 31; |
|
684 |
1 |
const uint32_t value = UINT32_MAX >> 1; |
|
685 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits); |
686 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
|
687 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
688 |
|||
689 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 16), CppRuntimeException); |
690 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 33), CppRuntimeException); |
691 |
} |
||
692 |
|||
693 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedUnsignedBitField33) // mapped to uint64_t |
694 |
{ |
||
695 |
1 |
const uint8_t numBits = 33; |
|
696 |
1 |
const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U; |
|
697 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits); |
698 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
|
699 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits64, _1, numBits), numBits); |
700 |
|||
701 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 32), CppRuntimeException); |
702 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 65), CppRuntimeException); |
703 |
} |
||
704 |
|||
705 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicSignedBitField5) // mapped to int8_t |
706 |
{ |
||
707 |
1 |
const uint8_t maxBitSize = 8; |
|
708 |
1 |
const uint8_t numBits = 5; |
|
709 |
1 |
const int8_t value = 15; |
|
710 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits); |
711 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt8, |
|
712 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
713 |
|||
714 |
// maxBitSize out of bounds |
||
715 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 9, numBits), CppRuntimeException); |
716 |
|||
717 |
// dynamicBitSize out of bounds |
||
718 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 4, numBits), CppRuntimeException); |
719 |
} |
||
720 |
|||
721 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicSignedBitField15) // mapped to int16_t |
722 |
{ |
||
723 |
1 |
const uint8_t maxBitSize = 16; |
|
724 |
1 |
const uint8_t numBits = 15; |
|
725 |
1 |
const int16_t value = -15; |
|
726 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits); |
727 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
|
728 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
729 |
|||
730 |
// maxBitSize out of bounds |
||
731 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 8, numBits), CppRuntimeException); |
732 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 17, numBits), CppRuntimeException); |
733 |
|||
734 |
// dynamicBitSize out of bounds |
||
735 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 12, numBits), CppRuntimeException); |
736 |
} |
||
737 |
|||
738 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicSignedBitField31) // mapped to int32_t |
739 |
{ |
||
740 |
1 |
const uint8_t maxBitSize = 32; |
|
741 |
1 |
const uint8_t numBits = 31; |
|
742 |
1 |
const int32_t value = -12345678; |
|
743 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits); |
744 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
|
745 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
746 |
|||
747 |
// maxBitSize out of bounds |
||
748 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 16, numBits), CppRuntimeException); |
749 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 33, numBits), CppRuntimeException); |
750 |
|||
751 |
// dynamicBitSize out of bounds |
||
752 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 29, numBits), CppRuntimeException); |
753 |
} |
||
754 |
|||
755 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicSignedBitField60) // mapped to int64_t |
756 |
{ |
||
757 |
1 |
const uint8_t maxBitSize = 64; |
|
758 |
1 |
const uint8_t numBits = 60; |
|
759 |
1 |
const int64_t value = 1234567890; |
|
760 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits); |
761 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
|
762 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits); |
763 |
|||
764 |
// maxBitSize out of bounds |
||
765 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 32, numBits), CppRuntimeException); |
766 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 65, numBits), CppRuntimeException); |
767 |
|||
768 |
// dynamicBitSize out of bounds |
||
769 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 58, numBits), CppRuntimeException); |
770 |
|||
771 |
// dynamic signed bit field as a type reference (maxBitSize must be 64!) |
||
772 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(ReflectableFactory::getDynamicSignedBitField(value, 64)); |
773 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 58), CppRuntimeException); |
774 |
} |
||
775 |
|||
776 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicUnsignedBitField7) // mapped to uint8_t |
777 |
{ |
||
778 |
1 |
const uint8_t maxBitSize = 8; |
|
779 |
1 |
const uint8_t numBits = 7; |
|
780 |
1 |
const uint8_t value = 0x2F; |
|
781 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits); |
782 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8, |
|
783 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
784 |
|||
785 |
// maxBitSize out of bounds |
||
786 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 9, numBits), CppRuntimeException); |
787 |
|||
788 |
// dynamicBitSize out of bounds |
||
789 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 6, numBits), CppRuntimeException); |
790 |
} |
||
791 |
|||
792 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicUnsignedBitField9) // mapped to uint16_t |
793 |
{ |
||
794 |
1 |
const uint8_t maxBitSize = 16; |
|
795 |
1 |
const uint8_t numBits = 9; |
|
796 |
1 |
const uint16_t value = 0x1FF; |
|
797 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits); |
798 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
|
799 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
800 |
|||
801 |
// maxBitSize out of bounds |
||
802 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 8, numBits), CppRuntimeException); |
803 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 17, numBits), CppRuntimeException); |
804 |
|||
805 |
// dynamicBitSize out of bounds |
||
806 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 9, 10), CppRuntimeException); |
807 |
} |
||
808 |
|||
809 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicUnsignedBitField31) // mapped to uint32_t |
810 |
{ |
||
811 |
1 |
const uint8_t maxBitSize = 32; |
|
812 |
1 |
const uint8_t numBits = 31; |
|
813 |
1 |
const uint32_t value = UINT32_MAX >> 1; |
|
814 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits); |
815 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
|
816 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
817 |
|||
818 |
// maxBitSize out of bounds |
||
819 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 16, numBits), CppRuntimeException); |
820 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 33, numBits), CppRuntimeException); |
821 |
|||
822 |
// dynamicBitSize out of bounds |
||
823 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 29, numBits), CppRuntimeException); |
824 |
} |
||
825 |
|||
826 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicUnsignedBitField33) // mapped to uint64_t |
827 |
{ |
||
828 |
1 |
const uint8_t maxBitSize = 64; |
|
829 |
1 |
const uint8_t numBits = 33; |
|
830 |
1 |
const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U; |
|
831 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits); |
832 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
|
833 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits64, _1, numBits), numBits); |
834 |
|||
835 |
// maxBitSize out of bounds |
||
836 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 32, numBits), CppRuntimeException); |
837 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 65, numBits), CppRuntimeException); |
838 |
|||
839 |
// dynamicBitSize out of bounds |
||
840 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 33, 34), CppRuntimeException); |
841 |
|||
842 |
// dynamic unsigned bit field as a type reference (maxBitSize must be 64!) |
||
843 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 64)); |
844 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 58), CppRuntimeException); |
845 |
} |
||
846 |
|||
847 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varint16Reflectable) |
848 |
{ |
||
849 |
1 |
const int16_t value = -1234; |
|
850 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt16(value); |
851 |
✓✗ | 3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
852 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarInt16, _1), bitSizeOfVarInt16(value)); |
853 |
1 |
} |
|
854 |
|||
855 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varint32Reflectable) |
856 |
{ |
||
857 |
1 |
const int32_t value = 54321; |
|
858 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt32(value); |
859 |
✓✗ | 3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
860 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarInt32, _1), bitSizeOfVarInt32(value)); |
861 |
1 |
} |
|
862 |
|||
863 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varint64Reflectable) |
864 |
{ |
||
865 |
1 |
const int64_t value = -87654321; |
|
866 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt64(value); |
867 |
✓✗ | 3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
868 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarInt64, _1), bitSizeOfVarInt64(value)); |
869 |
1 |
} |
|
870 |
|||
871 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varintReflectable) |
872 |
{ |
||
873 |
1 |
const int64_t value = INT64_MAX; |
|
874 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt(value); |
875 |
✓✗ | 3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
876 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarInt, _1), bitSizeOfVarInt(value)); |
877 |
1 |
} |
|
878 |
|||
879 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuint16Reflectable) |
880 |
{ |
||
881 |
1 |
const uint16_t value = 1234; |
|
882 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt16(value); |
883 |
✓✗ | 3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
884 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarUInt16, _1), bitSizeOfVarUInt16(value)); |
885 |
1 |
} |
|
886 |
|||
887 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuint32Reflectable) |
888 |
{ |
||
889 |
1 |
const uint32_t value = 0x1FFFFFFF; |
|
890 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt32(value); |
891 |
✓✗ | 3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
892 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarUInt32, _1), bitSizeOfVarUInt32(value)); |
893 |
1 |
} |
|
894 |
|||
895 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuint64Reflectable) |
896 |
{ |
||
897 |
1 |
const uint64_t value = 4242424242; |
|
898 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt64(value); |
899 |
✓✗ | 3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
900 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarUInt64, _1), bitSizeOfVarUInt64(value)); |
901 |
1 |
} |
|
902 |
|||
903 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuintReflectable) |
904 |
{ |
||
905 |
1 |
const uint64_t value = UINT64_MAX; |
|
906 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt(value); |
907 |
✓✗ | 3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
908 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarUInt, _1), bitSizeOfVarUInt(value)); |
909 |
1 |
} |
|
910 |
|||
911 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varsizeReflectable) |
912 |
{ |
||
913 |
1 |
const uint32_t value = (UINT32_C(1) << (7+7+7+7+3)) - 1; |
|
914 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarSize(value); |
915 |
✓✗ | 3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
916 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarSize, _1), bitSizeOfVarSize(value)); |
917 |
1 |
} |
|
918 |
|||
919 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, float16Reflectable) |
920 |
{ |
||
921 |
1 |
const float value = 2.0F; |
|
922 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat16(value); |
923 |
3 |
checkFloatingPoint(value, reflectable, &IReflectable::getFloat, |
|
924 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readFloat16, _1)); |
925 |
1 |
} |
|
926 |
|||
927 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, float32Reflectable) |
928 |
{ |
||
929 |
1 |
const float value = 1.2F; |
|
930 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat32(value); |
931 |
3 |
checkFloatingPoint(value, reflectable, &IReflectable::getFloat, |
|
932 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readFloat32, _1)); |
933 |
1 |
} |
|
934 |
|||
935 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, float64Reflectable) |
936 |
{ |
||
937 |
1 |
const double value = 1.2; |
|
938 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat64(value); |
939 |
3 |
checkFloatingPoint(value, reflectable, &IReflectable::getDouble, |
|
940 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readFloat64, _1)); |
941 |
1 |
} |
|
942 |
|||
943 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, stringReflectable) |
944 |
{ |
||
945 |
✓✗ | 2 |
const std::string value = "some longer string value to have a chance that some allocation hopefully occurs"; |
946 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getString(value); |
947 |
✓✗ | 1 |
checkString(value, reflectable); |
948 |
1 |
} |
|
949 |
|||
950 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, stringViewReflectable) |
951 |
{ |
||
952 |
1 |
auto view = makeStringView("some text as a string view"); |
|
953 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getString(view); |
954 |
✓✗ | 1 |
checkString(view, reflectable); |
955 |
1 |
} |
|
956 |
|||
957 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, bitBufferReflectable) |
958 |
{ |
||
959 |
✓✗✓✗ |
2 |
const BitBuffer value = BitBuffer{std::vector<uint8_t>({0xAB, 0xF0}), 12}; |
960 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getBitBuffer(value); |
961 |
✓✗ | 1 |
checkBitBuffer(value, reflectable); |
962 |
1 |
} |
|
963 |
|||
964 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, bytesReflectable) |
965 |
{ |
||
966 |
✓✗ | 2 |
const vector<uint8_t> value{{0, 127, 128, 255}}; |
967 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBytes(value); |
968 |
✓✗ | 1 |
checkBytes(value, reflectable); |
969 |
1 |
} |
|
970 |
|||
971 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, boolConstArray) |
972 |
{ |
||
973 |
✓✗ | 2 |
const auto rawArray = std::vector<bool>({true, false, true, false}); |
974 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getBoolArray(rawArray); |
975 |
2 |
checkArray(rawArray, reflectable, |
|
976 |
4 |
[&](bool value, const IReflectableConstPtr& elementReflectable) { |
|
977 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getBool, |
|
978 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBool, _1)); |
979 |
4 |
} |
|
980 |
✓✗ | 1 |
); |
981 |
1 |
} |
|
982 |
|||
983 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, boolArray) |
984 |
{ |
||
985 |
✓✗ | 2 |
auto rawArray = std::vector<bool>({true, false, true, false}); |
986 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getBoolArray(rawArray); |
987 |
2 |
checkArray(rawArray, reflectable, |
|
988 |
4 |
[&](bool value, const IReflectableConstPtr& elementReflectable) { |
|
989 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getBool, |
|
990 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBool, _1)); |
991 |
4 |
} |
|
992 |
✓✗ | 1 |
); |
993 |
1 |
} |
|
994 |
|||
995 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int8ConstArray) |
996 |
{ |
||
997 |
✓✗ | 2 |
const auto rawArray = std::vector<int8_t>({-10, -20, 30, 40}); |
998 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getInt8Array(rawArray); |
999 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
1000 |
4 |
[&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1001 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1002 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readSignedBits, _1, 8)); |
1003 |
4 |
} |
|
1004 |
✓✗ | 1 |
); |
1005 |
|||
1006 |
✓✗ | 2 |
auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1007 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1008 |
} |
||
1009 |
|||
1010 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int8Array) |
1011 |
{ |
||
1012 |
✓✗ | 2 |
auto rawArray = std::vector<int8_t>({-10, -20, 30, 40}); |
1013 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getInt8Array(rawArray); |
1014 |
2 |
checkArray(rawArray, reflectable, |
|
1015 |
4 |
[&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1016 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1017 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readSignedBits, _1, 8)); |
1018 |
4 |
} |
|
1019 |
✓✗ | 1 |
); |
1020 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1021 |
4 |
[&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1022 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1023 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readSignedBits, _1, 8)); |
1024 |
4 |
} |
|
1025 |
✓✗ | 1 |
); |
1026 |
|||
1027 |
✓✗ | 1 |
reflectable->resize(0); |
1028 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1029 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(static_cast<int8_t>(13))); |
1030 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1031 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(13, reflectable->at(0)->getInt8()); |
1032 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0); |
1033 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1034 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(42, reflectable->at(0)->getInt8()); |
1035 |
✓✗ | 1 |
reflectable->resize(2); |
1036 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1037 |
|||
1038 |
// out of range |
||
1039 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(-42)), 2), CppRuntimeException); |
1040 |
} |
||
1041 |
|||
1042 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int16ConstArray) |
1043 |
{ |
||
1044 |
✓✗ | 2 |
const auto rawArray = std::vector<int16_t>({-100, -200, 300, 400}); |
1045 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt16Array(rawArray); |
1046 |
2 |
checkArray(rawArray, reflectable, |
|
1047 |
4 |
[&](int16_t value, const IReflectableConstPtr& elementReflectable) { |
|
1048 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16, |
|
1049 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readSignedBits, _1, 16)); |
1050 |
4 |
} |
|
1051 |
✓✗ | 1 |
); |
1052 |
1 |
} |
|
1053 |
|||
1054 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int16Array) |
1055 |
{ |
||
1056 |
✓✗ | 2 |
auto rawArray = std::vector<int16_t>({-100, -200, 300, 400}); |
1057 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt16Array(rawArray); |
1058 |
2 |
checkArray(rawArray, reflectable, |
|
1059 |
4 |
[&](int16_t value, const IReflectableConstPtr& elementReflectable) { |
|
1060 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16, |
|
1061 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readSignedBits, _1, 16)); |
1062 |
4 |
} |
|
1063 |
✓✗ | 1 |
); |
1064 |
1 |
} |
|
1065 |
|||
1066 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int32ConstArray) |
1067 |
{ |
||
1068 |
✓✗ | 2 |
const auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000}); |
1069 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt32Array(rawArray); |
1070 |
2 |
checkArray(rawArray, reflectable, |
|
1071 |
4 |
[&](int32_t value, const IReflectableConstPtr& elementReflectable) { |
|
1072 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32, |
|
1073 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readSignedBits, _1, 32)); |
1074 |
4 |
} |
|
1075 |
✓✗ | 1 |
); |
1076 |
1 |
} |
|
1077 |
|||
1078 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int32Array) |
1079 |
{ |
||
1080 |
✓✗ | 2 |
auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000}); |
1081 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt32Array(rawArray); |
1082 |
2 |
checkArray(rawArray, reflectable, |
|
1083 |
4 |
[&](int32_t value, const IReflectableConstPtr& elementReflectable) { |
|
1084 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32, |
|
1085 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readSignedBits, _1, 32)); |
1086 |
4 |
} |
|
1087 |
✓✗ | 1 |
); |
1088 |
1 |
} |
|
1089 |
|||
1090 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int64ConstArray) |
1091 |
{ |
||
1092 |
✓✗ | 2 |
const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000}); |
1093 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt64Array(rawArray); |
1094 |
2 |
checkArray(rawArray, reflectable, |
|
1095 |
4 |
[&](int64_t value, const IReflectableConstPtr& elementReflectable) { |
|
1096 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
|
1097 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readSignedBits64, _1, 64)); |
1098 |
4 |
} |
|
1099 |
✓✗ | 1 |
); |
1100 |
1 |
} |
|
1101 |
|||
1102 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, int64Array) |
1103 |
{ |
||
1104 |
✓✗ | 2 |
auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000}); |
1105 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt64Array(rawArray); |
1106 |
2 |
checkArray(rawArray, reflectable, |
|
1107 |
4 |
[&](int64_t value, const IReflectableConstPtr& elementReflectable) { |
|
1108 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
|
1109 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readSignedBits64, _1, 64)); |
1110 |
4 |
} |
|
1111 |
✓✗ | 1 |
); |
1112 |
1 |
} |
|
1113 |
|||
1114 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint8ConstArray) |
1115 |
{ |
||
1116 |
✓✗ | 2 |
const auto rawArray = std::vector<uint8_t>({10, 20, 30, 40}); |
1117 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt8Array(rawArray); |
1118 |
2 |
checkArray(rawArray, reflectable, |
|
1119 |
4 |
[&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1120 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
|
1121 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBits, _1, 8)); |
1122 |
4 |
} |
|
1123 |
✓✗ | 1 |
); |
1124 |
1 |
} |
|
1125 |
|||
1126 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint8Array) |
1127 |
{ |
||
1128 |
✓✗ | 2 |
auto rawArray = std::vector<uint8_t>{{10, 20, 30, 40}}; |
1129 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt8Array(rawArray); |
1130 |
2 |
checkArray(rawArray, reflectable, |
|
1131 |
4 |
[&](uint8_t value, const IReflectablePtr& elementReflectable) { |
|
1132 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
|
1133 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBits, _1, 8)); |
1134 |
4 |
} |
|
1135 |
✓✗ | 1 |
); |
1136 |
1 |
} |
|
1137 |
|||
1138 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint16ConstArray) |
1139 |
{ |
||
1140 |
✓✗ | 2 |
const auto rawArray = std::vector<uint16_t>({100, 200, 300, 400}); |
1141 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt16Array(rawArray); |
1142 |
2 |
checkArray(rawArray, reflectable, |
|
1143 |
4 |
[&](uint16_t value, const IReflectableConstPtr& elementReflectable) { |
|
1144 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16, |
|
1145 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBits, _1, 16)); |
1146 |
4 |
} |
|
1147 |
✓✗ | 1 |
); |
1148 |
1 |
} |
|
1149 |
|||
1150 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint16Array) |
1151 |
{ |
||
1152 |
✓✗ | 2 |
auto rawArray = std::vector<uint16_t>{{100, 200, 300, 400}}; |
1153 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt16Array(rawArray); |
1154 |
2 |
checkArray(rawArray, reflectable, |
|
1155 |
4 |
[&](uint16_t value, const IReflectablePtr& elementReflectable) { |
|
1156 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16, |
|
1157 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBits, _1, 16)); |
1158 |
4 |
} |
|
1159 |
✓✗ | 1 |
); |
1160 |
1 |
} |
|
1161 |
|||
1162 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint32ConstArray) |
1163 |
{ |
||
1164 |
✓✗ | 2 |
const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000}); |
1165 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt32Array(rawArray); |
1166 |
2 |
checkArray(rawArray, reflectable, |
|
1167 |
4 |
[&](uint32_t value, const IReflectableConstPtr& elementReflectable) { |
|
1168 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
|
1169 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBits, _1, 32)); |
1170 |
4 |
} |
|
1171 |
✓✗ | 1 |
); |
1172 |
1 |
} |
|
1173 |
|||
1174 |
|||
1175 |
|||
1176 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint32Array) |
1177 |
{ |
||
1178 |
✓✗ | 2 |
auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}}; |
1179 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt32Array(rawArray); |
1180 |
2 |
checkArray(rawArray, reflectable, |
|
1181 |
4 |
[&](uint32_t value, const IReflectablePtr& elementReflectable) { |
|
1182 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
|
1183 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBits, _1, 32)); |
1184 |
4 |
} |
|
1185 |
✓✗ | 1 |
); |
1186 |
1 |
} |
|
1187 |
|||
1188 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint64ConstArray) |
1189 |
{ |
||
1190 |
✓✗ | 2 |
const auto rawArray = std::vector<uint64_t>({10000000, 20000000, 30000000, 40000000}); |
1191 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt64Array(rawArray); |
1192 |
2 |
checkArray(rawArray, reflectable, |
|
1193 |
4 |
[&](uint64_t value, const IReflectableConstPtr& elementReflectable) { |
|
1194 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
|
1195 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBits64, _1, 64)); |
1196 |
4 |
} |
|
1197 |
✓✗ | 1 |
); |
1198 |
1 |
} |
|
1199 |
|||
1200 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, uint64Array) |
1201 |
{ |
||
1202 |
✓✗ | 2 |
auto rawArray = std::vector<uint64_t>{{10000000, 20000000, 30000000, 40000000}}; |
1203 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt64Array(rawArray); |
1204 |
2 |
checkArray(rawArray, reflectable, |
|
1205 |
4 |
[&](uint64_t value, const IReflectablePtr& elementReflectable) { |
|
1206 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
|
1207 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBits64, _1, 64)); |
1208 |
4 |
} |
|
1209 |
✓✗ | 1 |
); |
1210 |
1 |
} |
|
1211 |
|||
1212 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedSignedBitField5ConstArray) |
1213 |
{ |
||
1214 |
1 |
const uint8_t numBits = 5; |
|
1215 |
✓✗ | 2 |
const auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}}; |
1216 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedSignedBitFieldArray(rawArray, numBits); |
1217 |
2 |
checkArray(rawArray, reflectable, |
|
1218 |
5 |
[&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1219 |
15 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1220 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1221 |
5 |
} |
|
1222 |
✓✗ | 1 |
); |
1223 |
1 |
} |
|
1224 |
|||
1225 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedSignedBitField5Array) |
1226 |
{ |
||
1227 |
1 |
const uint8_t numBits = 5; |
|
1228 |
✓✗ | 2 |
auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}}; |
1229 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getFixedSignedBitFieldArray(rawArray, numBits); |
1230 |
2 |
checkArray(rawArray, reflectable, |
|
1231 |
5 |
[&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1232 |
15 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1233 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1234 |
5 |
} |
|
1235 |
✓✗ | 1 |
); |
1236 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1237 |
5 |
[&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1238 |
15 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1239 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1240 |
5 |
} |
|
1241 |
✓✗ | 1 |
); |
1242 |
|||
1243 |
✓✗ | 1 |
reflectable->resize(0); |
1244 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1245 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(static_cast<int8_t>(13))); |
1246 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1247 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(13, reflectable->at(0)->getInt8()); |
1248 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0); |
1249 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1250 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(42, reflectable->at(0)->getInt8()); |
1251 |
✓✗ | 1 |
reflectable->resize(2); |
1252 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1253 |
|||
1254 |
// out of range |
||
1255 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 2), CppRuntimeException); |
1256 |
} |
||
1257 |
|||
1258 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedUnsignedBitField5ConstArray) |
1259 |
{ |
||
1260 |
1 |
const uint8_t numBits = 5; |
|
1261 |
✓✗ | 2 |
const auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}}; |
1262 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedUnsignedBitFieldArray(rawArray, numBits); |
1263 |
2 |
checkArray(rawArray, reflectable, |
|
1264 |
5 |
[&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1265 |
15 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
|
1266 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
1267 |
5 |
} |
|
1268 |
✓✗ | 1 |
); |
1269 |
1 |
} |
|
1270 |
|||
1271 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, fixedUnsignedBitField5Array) |
1272 |
{ |
||
1273 |
1 |
const uint8_t numBits = 5; |
|
1274 |
✓✗ | 2 |
auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}}; |
1275 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedUnsignedBitFieldArray(rawArray, numBits); |
1276 |
2 |
checkArray(rawArray, reflectable, |
|
1277 |
5 |
[&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1278 |
15 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
|
1279 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
1280 |
5 |
} |
|
1281 |
✓✗ | 1 |
); |
1282 |
1 |
} |
|
1283 |
|||
1284 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicSignedBitField5ConstArray) |
1285 |
{ |
||
1286 |
1 |
const uint8_t maxBitSize = 8; |
|
1287 |
1 |
const uint8_t numBits = 5; |
|
1288 |
✓✗ | 2 |
const auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}}; |
1289 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getDynamicSignedBitFieldArray(rawArray, maxBitSize, numBits); |
1290 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
1291 |
5 |
[&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1292 |
15 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1293 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1294 |
5 |
} |
|
1295 |
✓✗ | 1 |
); |
1296 |
|||
1297 |
✓✗ | 2 |
auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1298 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1299 |
} |
||
1300 |
|||
1301 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicSignedBitField5Array) |
1302 |
{ |
||
1303 |
1 |
const uint8_t maxBitSize = 8; |
|
1304 |
1 |
const uint8_t numBits = 5; |
|
1305 |
✓✗ | 2 |
auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}}; |
1306 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getDynamicSignedBitFieldArray(rawArray, maxBitSize, numBits); |
1307 |
2 |
checkArray(rawArray, reflectable, |
|
1308 |
5 |
[&](int8_t value, const IReflectablePtr& elementReflectable) { |
|
1309 |
15 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1310 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1311 |
5 |
} |
|
1312 |
✓✗ | 1 |
); |
1313 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1314 |
5 |
[&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1315 |
15 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1316 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1317 |
5 |
} |
|
1318 |
✓✗ | 1 |
); |
1319 |
|||
1320 |
✓✗ | 1 |
reflectable->resize(0); |
1321 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1322 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(static_cast<int8_t>(13))); |
1323 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1324 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(13, reflectable->at(0)->getInt8()); |
1325 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0); |
1326 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1327 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(42, reflectable->at(0)->getInt8()); |
1328 |
✓✗ | 1 |
reflectable->resize(2); |
1329 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1330 |
|||
1331 |
// out of range |
||
1332 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 2), CppRuntimeException); |
1333 |
} |
||
1334 |
|||
1335 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicUnsignedBitField5ConstArray) |
1336 |
{ |
||
1337 |
1 |
const uint8_t maxBitSize = 8; |
|
1338 |
1 |
const uint8_t numBits = 5; |
|
1339 |
✓✗ | 2 |
const auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}}; |
1340 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicUnsignedBitFieldArray(rawArray, maxBitSize, numBits); |
1341 |
2 |
checkArray(rawArray, reflectable, |
|
1342 |
5 |
[&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1343 |
15 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
|
1344 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
1345 |
5 |
} |
|
1346 |
✓✗ | 1 |
); |
1347 |
1 |
} |
|
1348 |
|||
1349 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, dynamicUnsignedBitField5Array) |
1350 |
{ |
||
1351 |
1 |
const uint8_t maxBitSize = 8; |
|
1352 |
1 |
const uint8_t numBits = 5; |
|
1353 |
✓✗ | 2 |
auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}}; |
1354 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicUnsignedBitFieldArray(rawArray, maxBitSize, numBits); |
1355 |
2 |
checkArray(rawArray, reflectable, |
|
1356 |
5 |
[&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1357 |
15 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
|
1358 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
1359 |
5 |
} |
|
1360 |
✓✗ | 1 |
); |
1361 |
1 |
} |
|
1362 |
|||
1363 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varint16ConstArray) |
1364 |
{ |
||
1365 |
✓✗ | 2 |
const auto rawArray = std::vector<int16_t>({-10, -20, 30, 40}); |
1366 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt16Array(rawArray); |
1367 |
2 |
checkArray(rawArray, reflectable, |
|
1368 |
4 |
[&](int16_t value, const IReflectableConstPtr& elementReflectable) { |
|
1369 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16, |
|
1370 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarInt16, _1)); |
1371 |
4 |
} |
|
1372 |
✓✗ | 1 |
); |
1373 |
1 |
} |
|
1374 |
|||
1375 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varint16Array) |
1376 |
{ |
||
1377 |
✓✗ | 2 |
auto rawArray = std::vector<int16_t>{{-10, -20, 30, 40}}; |
1378 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt16Array(rawArray); |
1379 |
2 |
checkArray(rawArray, reflectable, |
|
1380 |
4 |
[&](int16_t value, const IReflectablePtr& elementReflectable) { |
|
1381 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16, |
|
1382 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarInt16, _1)); |
1383 |
4 |
} |
|
1384 |
✓✗ | 1 |
); |
1385 |
1 |
} |
|
1386 |
|||
1387 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varint32ConstArray) |
1388 |
{ |
||
1389 |
✓✗ | 2 |
const auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000}); |
1390 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt32Array(rawArray); |
1391 |
2 |
checkArray(rawArray, reflectable, |
|
1392 |
4 |
[&](int32_t value, const IReflectableConstPtr& elementReflectable) { |
|
1393 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32, |
|
1394 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarInt32, _1)); |
1395 |
4 |
} |
|
1396 |
✓✗ | 1 |
); |
1397 |
1 |
} |
|
1398 |
|||
1399 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varint32Array) |
1400 |
{ |
||
1401 |
✓✗ | 2 |
auto rawArray = std::vector<int32_t>{{-10000, -20000, 30000, 40000}}; |
1402 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt32Array(rawArray); |
1403 |
2 |
checkArray(rawArray, reflectable, |
|
1404 |
4 |
[&](int32_t value, const IReflectablePtr& elementReflectable) { |
|
1405 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32, |
|
1406 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarInt32, _1)); |
1407 |
4 |
} |
|
1408 |
✓✗ | 1 |
); |
1409 |
1 |
} |
|
1410 |
|||
1411 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varint64ConstArray) |
1412 |
{ |
||
1413 |
✓✗ | 2 |
const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000}); |
1414 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt64Array(rawArray); |
1415 |
2 |
checkArray(rawArray, reflectable, |
|
1416 |
4 |
[&](int64_t value, const IReflectableConstPtr& elementReflectable) { |
|
1417 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
|
1418 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarInt64, _1)); |
1419 |
4 |
} |
|
1420 |
✓✗ | 1 |
); |
1421 |
1 |
} |
|
1422 |
|||
1423 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varint64Array) |
1424 |
{ |
||
1425 |
✓✗ | 2 |
auto rawArray = std::vector<int64_t>{{-10000000, -20000000, 30000000, 40000000}}; |
1426 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt64Array(rawArray); |
1427 |
2 |
checkArray(rawArray, reflectable, |
|
1428 |
4 |
[&](int64_t value, const IReflectablePtr& elementReflectable) { |
|
1429 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
|
1430 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarInt64, _1)); |
1431 |
4 |
} |
|
1432 |
✓✗ | 1 |
); |
1433 |
1 |
} |
|
1434 |
|||
1435 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varintConstArray) |
1436 |
{ |
||
1437 |
✓✗ | 2 |
const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000}); |
1438 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarIntArray(rawArray); |
1439 |
2 |
checkArray(rawArray, reflectable, |
|
1440 |
4 |
[&](int64_t value, const IReflectableConstPtr& elementReflectable) { |
|
1441 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
|
1442 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarInt, _1)); |
1443 |
4 |
} |
|
1444 |
✓✗ | 1 |
); |
1445 |
1 |
} |
|
1446 |
|||
1447 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varintArray) |
1448 |
{ |
||
1449 |
✓✗ | 2 |
auto rawArray = std::vector<int64_t>{{-10000000, -20000000, 30000000, 40000000}}; |
1450 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarIntArray(rawArray); |
1451 |
2 |
checkArray(rawArray, reflectable, |
|
1452 |
4 |
[&](int64_t value, const IReflectablePtr& elementReflectable) { |
|
1453 |
16 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
|
1454 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarInt, _1)); |
1455 |
4 |
} |
|
1456 |
✓✗ | 1 |
); |
1457 |
1 |
} |
|
1458 |
|||
1459 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuint16ConstArray) |
1460 |
{ |
||
1461 |
✓✗ | 2 |
const auto rawArray = std::vector<uint16_t>({10, 20, 30, 40}); |
1462 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt16Array(rawArray); |
1463 |
2 |
checkArray(rawArray, reflectable, |
|
1464 |
4 |
[&](uint16_t value, const IReflectableConstPtr& elementReflectable) { |
|
1465 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16, |
|
1466 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarUInt16, _1)); |
1467 |
4 |
} |
|
1468 |
✓✗ | 1 |
); |
1469 |
1 |
} |
|
1470 |
|||
1471 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuint16Array) |
1472 |
{ |
||
1473 |
✓✗ | 2 |
auto rawArray = std::vector<uint16_t>{{10, 20, 30, 40}}; |
1474 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt16Array(rawArray); |
1475 |
2 |
checkArray(rawArray, reflectable, |
|
1476 |
4 |
[&](uint16_t value, const IReflectablePtr& elementReflectable) { |
|
1477 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16, |
|
1478 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarUInt16, _1)); |
1479 |
4 |
} |
|
1480 |
✓✗ | 1 |
); |
1481 |
1 |
} |
|
1482 |
|||
1483 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuint32ConstArray) |
1484 |
{ |
||
1485 |
✓✗ | 2 |
const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000}); |
1486 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt32Array(rawArray); |
1487 |
2 |
checkArray(rawArray, reflectable, |
|
1488 |
4 |
[&](uint32_t value, const IReflectableConstPtr& elementReflectable) { |
|
1489 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
|
1490 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarUInt32, _1)); |
1491 |
4 |
} |
|
1492 |
✓✗ | 1 |
); |
1493 |
1 |
} |
|
1494 |
|||
1495 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuint32Array) |
1496 |
{ |
||
1497 |
✓✗ | 2 |
auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}}; |
1498 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt32Array(rawArray); |
1499 |
2 |
checkArray(rawArray, reflectable, |
|
1500 |
4 |
[&](uint32_t value, const IReflectablePtr& elementReflectable) { |
|
1501 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
|
1502 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarUInt32, _1)); |
1503 |
4 |
} |
|
1504 |
✓✗ | 1 |
); |
1505 |
1 |
} |
|
1506 |
|||
1507 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuint64ConstArray) |
1508 |
{ |
||
1509 |
✓✗ | 2 |
const auto rawArray = std::vector<uint64_t>({10000, 20000, 30000, 40000}); |
1510 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt64Array(rawArray); |
1511 |
2 |
checkArray(rawArray, reflectable, |
|
1512 |
4 |
[&](uint64_t value, const IReflectableConstPtr& elementReflectable) { |
|
1513 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
|
1514 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarUInt64, _1)); |
1515 |
4 |
} |
|
1516 |
✓✗ | 1 |
); |
1517 |
1 |
} |
|
1518 |
|||
1519 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuint64Array) |
1520 |
{ |
||
1521 |
✓✗ | 2 |
auto rawArray = std::vector<uint64_t>{{10000, 20000, 30000, 40000}}; |
1522 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt64Array(rawArray); |
1523 |
2 |
checkArray(rawArray, reflectable, |
|
1524 |
4 |
[&](uint64_t value, const IReflectablePtr& elementReflectable) { |
|
1525 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
|
1526 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarUInt64, _1)); |
1527 |
4 |
} |
|
1528 |
✓✗ | 1 |
); |
1529 |
1 |
} |
|
1530 |
|||
1531 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuintConstArray) |
1532 |
{ |
||
1533 |
✓✗ | 2 |
const auto rawArray = std::vector<uint64_t>({10000, 20000, 30000, 40000}); |
1534 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUIntArray(rawArray); |
1535 |
2 |
checkArray(rawArray, reflectable, |
|
1536 |
4 |
[&](uint64_t value, const IReflectableConstPtr& elementReflectable) { |
|
1537 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
|
1538 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarUInt, _1)); |
1539 |
4 |
} |
|
1540 |
✓✗ | 1 |
); |
1541 |
1 |
} |
|
1542 |
|||
1543 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varuintArray) |
1544 |
{ |
||
1545 |
✓✗ | 2 |
auto rawArray = std::vector<uint64_t>{{10000, 20000, 30000, 40000}}; |
1546 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUIntArray(rawArray); |
1547 |
2 |
checkArray(rawArray, reflectable, |
|
1548 |
4 |
[&](uint64_t value, const IReflectablePtr& elementReflectable) { |
|
1549 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
|
1550 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarUInt, _1)); |
1551 |
4 |
} |
|
1552 |
✓✗ | 1 |
); |
1553 |
1 |
} |
|
1554 |
|||
1555 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varsizeConstArray) |
1556 |
{ |
||
1557 |
✓✗ | 2 |
const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000}); |
1558 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarSizeArray(rawArray); |
1559 |
2 |
checkArray(rawArray, reflectable, |
|
1560 |
4 |
[&](uint32_t value, const IReflectableConstPtr& elementReflectable) { |
|
1561 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
|
1562 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarSize, _1)); |
1563 |
4 |
} |
|
1564 |
✓✗ | 1 |
); |
1565 |
1 |
} |
|
1566 |
|||
1567 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, varsizeArray) |
1568 |
{ |
||
1569 |
✓✗ | 2 |
auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}}; |
1570 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarSizeArray(rawArray); |
1571 |
2 |
checkArray(rawArray, reflectable, |
|
1572 |
4 |
[&](uint32_t value, const IReflectablePtr& elementReflectable) { |
|
1573 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
|
1574 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readVarSize, _1)); |
1575 |
4 |
} |
|
1576 |
✓✗ | 1 |
); |
1577 |
1 |
} |
|
1578 |
|||
1579 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, float16ConstArray) |
1580 |
{ |
||
1581 |
✓✗ | 2 |
const auto rawArray = std::vector<float>{{2.0F, 0.0F}}; |
1582 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat16Array(rawArray); |
1583 |
2 |
checkArray(rawArray, reflectable, |
|
1584 |
2 |
[&](float value, const IReflectableConstPtr& elementReflectable) { |
|
1585 |
8 |
checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat, |
|
1586 |
✓✗✓✗ |
8 |
std::bind(&BitStreamReader::readFloat16, _1)); |
1587 |
2 |
} |
|
1588 |
✓✗ | 1 |
); |
1589 |
1 |
} |
|
1590 |
|||
1591 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, float16Array) |
1592 |
{ |
||
1593 |
✓✗ | 2 |
auto rawArray = std::vector<float>{{2.0F, 0.0F}}; |
1594 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat16Array(rawArray); |
1595 |
2 |
checkArray(rawArray, reflectable, |
|
1596 |
2 |
[&](float value, const IReflectablePtr& elementReflectable) { |
|
1597 |
8 |
checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat, |
|
1598 |
✓✗✓✗ |
8 |
std::bind(&BitStreamReader::readFloat16, _1)); |
1599 |
2 |
} |
|
1600 |
✓✗ | 1 |
); |
1601 |
1 |
} |
|
1602 |
|||
1603 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, float32ConstArray) |
1604 |
{ |
||
1605 |
✓✗ | 2 |
const auto rawArray = std::vector<float>{{2.0F, 0.0F, 1.2F}}; |
1606 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat32Array(rawArray); |
1607 |
2 |
checkArray(rawArray, reflectable, |
|
1608 |
3 |
[&](float value, const IReflectableConstPtr& elementReflectable) { |
|
1609 |
12 |
checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat, |
|
1610 |
✓✗✓✗ |
12 |
std::bind(&BitStreamReader::readFloat32, _1)); |
1611 |
3 |
} |
|
1612 |
✓✗ | 1 |
); |
1613 |
1 |
} |
|
1614 |
|||
1615 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, float32Array) |
1616 |
{ |
||
1617 |
✓✗ | 2 |
auto rawArray = std::vector<float>{{2.0F, 0.0F, 1.2F}}; |
1618 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat32Array(rawArray); |
1619 |
2 |
checkArray(rawArray, reflectable, |
|
1620 |
3 |
[&](float value, const IReflectablePtr& elementReflectable) { |
|
1621 |
12 |
checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat, |
|
1622 |
✓✗✓✗ |
12 |
std::bind(&BitStreamReader::readFloat32, _1)); |
1623 |
3 |
} |
|
1624 |
✓✗ | 1 |
); |
1625 |
1 |
} |
|
1626 |
|||
1627 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, float64ConstArray) |
1628 |
{ |
||
1629 |
✓✗ | 2 |
const auto rawArray = std::vector<double>{{2.0, 0.0, 1.2}}; |
1630 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat64Array(rawArray); |
1631 |
2 |
checkArray(rawArray, reflectable, |
|
1632 |
3 |
[&](double value, const IReflectableConstPtr& elementReflectable) { |
|
1633 |
12 |
checkFloatingPoint(value, elementReflectable, &IReflectable::getDouble, |
|
1634 |
✓✗✓✗ |
12 |
std::bind(&BitStreamReader::readFloat64, _1)); |
1635 |
3 |
} |
|
1636 |
✓✗ | 1 |
); |
1637 |
1 |
} |
|
1638 |
|||
1639 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, float64Array) |
1640 |
{ |
||
1641 |
✓✗ | 2 |
auto rawArray = std::vector<double>{{2.0, 0.0, 1.2}}; |
1642 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat64Array(rawArray); |
1643 |
2 |
checkArray(rawArray, reflectable, |
|
1644 |
3 |
[&](double value, const IReflectablePtr& elementReflectable) { |
|
1645 |
12 |
checkFloatingPoint(value, elementReflectable, &IReflectable::getDouble, |
|
1646 |
✓✗✓✗ |
12 |
std::bind(&BitStreamReader::readFloat64, _1)); |
1647 |
3 |
} |
|
1648 |
✓✗ | 1 |
); |
1649 |
1 |
} |
|
1650 |
|||
1651 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, stringConstArray) |
1652 |
{ |
||
1653 |
✓✗✓✗ ✓✗✓✗ ✓✓✗✗ |
2 |
const auto rawArray = std::vector<std::string>{{"one", "two", "three"}}; |
1654 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getStringArray(rawArray); |
1655 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
1656 |
3 |
[&](StringView value, const IReflectableConstPtr& elementReflectable) { |
|
1657 |
3 |
checkString(value, elementReflectable); |
|
1658 |
3 |
} |
|
1659 |
✓✗ | 1 |
); |
1660 |
|||
1661 |
✓✗ | 2 |
auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1662 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1663 |
} |
||
1664 |
|||
1665 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, stringArray) |
1666 |
{ |
||
1667 |
✓✗✓✗ ✓✗✓✗ ✓✓✗✗ |
2 |
auto rawArray = std::vector<std::string>{{"one", "two", "three"}}; |
1668 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getStringArray(rawArray); |
1669 |
2 |
checkArray(rawArray, reflectable, |
|
1670 |
3 |
[&](StringView value, const IReflectablePtr& elementReflectable) { |
|
1671 |
3 |
checkString(value, elementReflectable); |
|
1672 |
3 |
} |
|
1673 |
✓✗ | 1 |
); |
1674 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1675 |
3 |
[&](StringView value, const IReflectableConstPtr& elementReflectable) { |
|
1676 |
3 |
checkString(value, elementReflectable); |
|
1677 |
3 |
} |
|
1678 |
✓✗ | 1 |
); |
1679 |
|||
1680 |
✓✗ | 1 |
reflectable->resize(0); |
1681 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1682 |
✓✗✓✗ ✓✗ |
1 |
reflectable->append(AnyHolder<>(std::string("appended"))); |
1683 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1684 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("appended"_sv, reflectable->at(0)->getStringView()); |
1685 |
✓✗✓✗ ✓✗ |
1 |
reflectable->setAt(AnyHolder<>(std::string("set")), 0); |
1686 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1687 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("set"_sv, reflectable->at(0)->getStringView()); |
1688 |
✓✗ | 1 |
reflectable->resize(2); |
1689 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1690 |
|||
1691 |
// out of range |
||
1692 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::string("set")), 2), CppRuntimeException); |
1693 |
} |
||
1694 |
|||
1695 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, bitBufferConstArray) |
1696 |
{ |
||
1697 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✓ ✗✗ |
2 |
const auto rawArray = std::vector<BitBuffer>{{BitBuffer({0xF8}, 5), BitBuffer({0xAB, 0xCD}, 16)}}; |
1698 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getBitBufferArray(rawArray); |
1699 |
2 |
checkArray(rawArray, reflectable, |
|
1700 |
2 |
[&](const BitBuffer& value, const IReflectableConstPtr& elementReflectable) { |
|
1701 |
2 |
checkBitBuffer(value, elementReflectable); |
|
1702 |
2 |
} |
|
1703 |
✓✗ | 1 |
); |
1704 |
1 |
} |
|
1705 |
|||
1706 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, bitBufferArray) |
1707 |
{ |
||
1708 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✓ ✗✗ |
2 |
auto rawArray = std::vector<BitBuffer>{{BitBuffer({0xF8}, 5), BitBuffer({0xAB, 0xCD}, 16)}}; |
1709 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBitBufferArray(rawArray); |
1710 |
2 |
checkArray(rawArray, reflectable, |
|
1711 |
2 |
[&](const BitBuffer& value, const IReflectablePtr& elementReflectable) { |
|
1712 |
2 |
checkBitBuffer(value, elementReflectable); |
|
1713 |
2 |
} |
|
1714 |
✓✗ | 1 |
); |
1715 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1716 |
2 |
[&](const BitBuffer& value, const IReflectableConstPtr& elementReflectable) { |
|
1717 |
2 |
checkBitBuffer(value, elementReflectable); |
|
1718 |
2 |
} |
|
1719 |
✓✗ | 1 |
); |
1720 |
|||
1721 |
✓✗ | 1 |
reflectable->resize(0); |
1722 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1723 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(BitBuffer())); |
1724 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1725 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(0, reflectable->at(0)->getBitBuffer().getBitSize()); |
1726 |
✓✗✓✗ ✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(BitBuffer({0xA0}, 4)), 0); |
1727 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1728 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(4, reflectable->at(0)->getBitBuffer().getBitSize()); |
1729 |
✓✗ | 1 |
reflectable->resize(2); |
1730 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1731 |
|||
1732 |
// out of range |
||
1733 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(BitBuffer()), 2), CppRuntimeException); |
1734 |
} |
||
1735 |
|||
1736 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, bytesConstArray) |
1737 |
{ |
||
1738 |
const auto rawArray = std::vector<std::vector<uint8_t>>{{ |
||
1739 |
{{0x00, 0x01}}, |
||
1740 |
{{0xFF, 0xFE}} |
||
1741 |
✓✗✓✗ ✓✗✓✓ ✗✗ |
2 |
}}; |
1742 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getBytesArray(rawArray); |
1743 |
2 |
checkArray(rawArray, reflectable, |
|
1744 |
2 |
[&](const vector<uint8_t>& value, const IReflectableConstPtr& elementReflectable) { |
|
1745 |
2 |
checkBytes(value, elementReflectable); |
|
1746 |
2 |
} |
|
1747 |
✓✗ | 1 |
); |
1748 |
1 |
} |
|
1749 |
|||
1750 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, bytesArray) |
1751 |
{ |
||
1752 |
auto rawArray = std::vector<std::vector<uint8_t>>{{ |
||
1753 |
{{0x00, 0x01}}, |
||
1754 |
{{0xFF, 0xFE}} |
||
1755 |
✓✗✓✗ ✓✗✓✓ ✗✗ |
2 |
}}; |
1756 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBytesArray(rawArray); |
1757 |
2 |
checkArray(rawArray, reflectable, |
|
1758 |
2 |
[&](const vector<uint8_t>& value, const IReflectablePtr& elementReflectable) { |
|
1759 |
2 |
checkBytes(value, elementReflectable); |
|
1760 |
2 |
} |
|
1761 |
✓✗ | 1 |
); |
1762 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1763 |
2 |
[&](const vector<uint8_t>& value, const IReflectableConstPtr& elementReflectable) { |
|
1764 |
2 |
checkBytes(value, elementReflectable); |
|
1765 |
2 |
} |
|
1766 |
✓✗ | 1 |
); |
1767 |
|||
1768 |
✓✗ | 1 |
reflectable->resize(0); |
1769 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1770 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(std::vector<uint8_t>())); |
1771 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1772 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(0, reflectable->at(0)->getBytes().size()); |
1773 |
✓✗✓✗ ✓✗ |
1 |
reflectable->setAt(AnyHolder<>(std::vector<uint8_t>{{0xAB, 0xCD}}), 0); |
1774 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1775 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(2, reflectable->at(0)->getBytes().size()); |
1776 |
✓✗ | 1 |
reflectable->resize(2); |
1777 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1778 |
|||
1779 |
// out of range |
||
1780 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::vector<uint8_t>()), 2), CppRuntimeException); |
1781 |
} |
||
1782 |
|||
1783 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, bitmaskConstReflectable) |
1784 |
{ |
||
1785 |
1 |
const ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE; |
|
1786 |
✓✗ | 2 |
auto reflectable = bitmask.reflectable(); |
1787 |
✓✗ | 1 |
checkBitmask(bitmask, reflectable); |
1788 |
1 |
} |
|
1789 |
|||
1790 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, bitmaskReflectable) |
1791 |
{ |
||
1792 |
1 |
ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE; |
|
1793 |
✓✗ | 2 |
auto reflectable = bitmask.reflectable(); |
1794 |
✓✗ | 1 |
checkBitmask(bitmask, reflectable); |
1795 |
1 |
} |
|
1796 |
|||
1797 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, bitmaskConstArray) |
1798 |
{ |
||
1799 |
const auto rawArray = std::vector<ReflectableBitmask>{{ |
||
1800 |
ReflectableBitmask::Values::WRITE, ReflectableBitmask::Values::CREATE, |
||
1801 |
ReflectableBitmask::Values::READ |
||
1802 |
✓✗ | 2 |
}}; |
1803 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBitmaskArray(rawArray); |
1804 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
1805 |
3 |
[&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) { |
|
1806 |
3 |
checkBitmask(value, elementReflectable); |
|
1807 |
3 |
} |
|
1808 |
✓✗ | 1 |
); |
1809 |
|||
1810 |
✓✗ | 2 |
auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1811 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1812 |
} |
||
1813 |
|||
1814 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, bitmaskArray) |
1815 |
{ |
||
1816 |
auto rawArray = std::vector<ReflectableBitmask>{{ |
||
1817 |
ReflectableBitmask::Values::WRITE, ReflectableBitmask::Values::CREATE, |
||
1818 |
ReflectableBitmask::Values::READ |
||
1819 |
✓✗ | 2 |
}}; |
1820 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBitmaskArray(rawArray); |
1821 |
2 |
checkArray(rawArray, reflectable, |
|
1822 |
3 |
[&](ReflectableBitmask value, const IReflectablePtr& elementReflectable) { |
|
1823 |
3 |
checkBitmask(value, elementReflectable); |
|
1824 |
3 |
} |
|
1825 |
✓✗ | 1 |
); |
1826 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1827 |
3 |
[&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) { |
|
1828 |
3 |
checkBitmask(value, elementReflectable); |
|
1829 |
3 |
} |
|
1830 |
✓✗ | 1 |
); |
1831 |
|||
1832 |
✓✗ | 1 |
reflectable->resize(0); |
1833 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1834 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ))); |
1835 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1836 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(0)->getUInt8())); |
1837 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::CREATE)), 0); |
1838 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1839 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(ReflectableBitmask::Values::CREATE, ReflectableBitmask(reflectable->at(0)->getUInt8())); |
1840 |
✓✗ | 1 |
reflectable->resize(2); |
1841 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1842 |
|||
1843 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::WRITE).getValue())); |
1844 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(3, reflectable->size()); |
1845 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(ReflectableBitmask::Values::WRITE, ReflectableBitmask(reflectable->at(2)->getUInt8())); |
1846 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ).getValue()), 2); |
1847 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(3, reflectable->size()); |
1848 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(2)->getUInt8())); |
1849 |
|||
1850 |
// out of range |
||
1851 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableBitmask::Values::CREATE), 3), CppRuntimeException); |
1852 |
} |
||
1853 |
|||
1854 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, enumReflectable) |
1855 |
{ |
||
1856 |
1 |
const ReflectableEnum enumeration = ReflectableEnum::VALUE1; |
|
1857 |
✓✗ | 2 |
auto reflectable = enumReflectable(enumeration); |
1858 |
✓✗ | 1 |
checkEnum(enumeration, reflectable); |
1859 |
1 |
} |
|
1860 |
|||
1861 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, enumConstArray) |
1862 |
{ |
||
1863 |
const auto rawArray = std::vector<ReflectableEnum>{{ReflectableEnum::VALUE1, ReflectableEnum::VALUE2, |
||
1864 |
✓✗ | 2 |
ReflectableEnum::VALUE3}}; |
1865 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getEnumArray(rawArray); |
1866 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
1867 |
3 |
[&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) { |
|
1868 |
3 |
checkEnum(value, elementReflectable); |
|
1869 |
3 |
} |
|
1870 |
✓✗ | 1 |
); |
1871 |
|||
1872 |
✓✗ | 2 |
auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1873 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1874 |
} |
||
1875 |
|||
1876 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, enumArray) |
1877 |
{ |
||
1878 |
auto rawArray = std::vector<ReflectableEnum>{{ReflectableEnum::VALUE1, ReflectableEnum::VALUE2, |
||
1879 |
✓✗ | 2 |
ReflectableEnum::VALUE3}}; |
1880 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getEnumArray(rawArray); |
1881 |
2 |
checkArray(rawArray, reflectable, |
|
1882 |
3 |
[&](ReflectableEnum value, const IReflectablePtr& elementReflectable) { |
|
1883 |
3 |
checkEnum(value, elementReflectable); |
|
1884 |
3 |
} |
|
1885 |
✓✗ | 1 |
); |
1886 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1887 |
3 |
[&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) { |
|
1888 |
3 |
checkEnum(value, elementReflectable); |
|
1889 |
3 |
} |
|
1890 |
✓✗ | 1 |
); |
1891 |
|||
1892 |
✓✗ | 1 |
reflectable->resize(0); |
1893 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1894 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(ReflectableEnum::VALUE3)); |
1895 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1896 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(enumToValue(ReflectableEnum::VALUE3), reflectable->at(0)->getInt8()); |
1897 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 0); |
1898 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1899 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(0)->getInt8()); |
1900 |
✓✗ | 1 |
reflectable->resize(2); |
1901 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1902 |
|||
1903 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(enumToValue(ReflectableEnum::VALUE1))); |
1904 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(3, reflectable->size()); |
1905 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(enumToValue(ReflectableEnum::VALUE1), reflectable->at(2)->getInt8()); |
1906 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(enumToValue(ReflectableEnum::VALUE2)), 2); |
1907 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(3, reflectable->size()); |
1908 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(2)->getInt8()); |
1909 |
|||
1910 |
// out of range |
||
1911 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 3), CppRuntimeException); |
1912 |
} |
||
1913 |
|||
1914 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, compoundConst) |
1915 |
{ |
||
1916 |
{ |
||
1917 |
const ReflectableObject reflectableObjectUninitialized = ReflectableObject{"test", |
||
1918 |
✓✗ | 2 |
ReflectableNested{13}}; |
1919 |
✓✗✓✗ |
2 |
auto reflectable = reflectableObjectUninitialized.reflectable(); |
1920 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_FALSE(reflectable->find("reflectableNested.stringParam")); |
1921 |
} |
||
1922 |
|||
1923 |
✓✗✓✗ |
2 |
const ReflectableObject reflectableObject = createInitializedReflectableObject("test", 13); |
1924 |
✓✗✓✗ ✓✗✗ |
2 |
auto reflectable = reflectableObject.reflectable(); |
1925 |
✓✗ | 1 |
checkCompound(reflectableObject, reflectable); |
1926 |
|||
1927 |
✓✗ | 2 |
IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1928 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->initializeChildren(), CppRuntimeException); |
1929 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(nonConstReflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException); |
1930 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(reflectable->getField("reflectableNested")); |
1931 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getField("reflectableNested"), CppRuntimeException); |
1932 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
1 |
ASSERT_NO_THROW(reflectable->getAnyValue()); |
1933 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1934 |
|||
1935 |
✓✗✓✗ |
2 |
IReflectableConstPtr childReflectable = reflectable->getField("reflectableNested"); |
1936 |
✓✗ | 2 |
IReflectablePtr nonConstChildReflectable =std::const_pointer_cast<IReflectable>(childReflectable); |
1937 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(nonConstChildReflectable->setField("value", AnyHolder<>(static_cast<uint32_t>(11))), |
1938 |
CppRuntimeException); |
||
1939 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(childReflectable->getParameter("dummyParam")); |
1940 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(nonConstChildReflectable->getParameter("dummyParam"), CppRuntimeException); |
1941 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(childReflectable->callFunction("getValue")); |
1942 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
2 |
ASSERT_THROW(nonConstChildReflectable->callFunction("getValue"), CppRuntimeException); |
1943 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstChildReflectable->initializeOffsets(0), CppRuntimeException); |
1944 |
} |
||
1945 |
|||
1946 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, compound) |
1947 |
{ |
||
1948 |
{ |
||
1949 |
✓✗ | 2 |
ReflectableObject reflectableObjectUninitialized = ReflectableObject{"test", ReflectableNested{13}}; |
1950 |
✓✗✓✗ |
2 |
auto reflectable = reflectableObjectUninitialized.reflectable(); |
1951 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_FALSE(reflectable->find("reflectableNested.stringParam")); |
1952 |
} |
||
1953 |
|||
1954 |
✓✗ | 2 |
ReflectableObject reflectableObject = ReflectableObject{"test", ReflectableNested{13}}; |
1955 |
✓✗✓✗ |
2 |
auto reflectable = reflectableObject.reflectable(); |
1956 |
|||
1957 |
// not initialized |
||
1958 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam"), CppRuntimeException); |
1959 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam"), CppRuntimeException); |
1960 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(static_cast<IReflectableConstPtr>(reflectable)->find("reflectableNested.stringParam")); |
1961 |
|||
1962 |
✓✗ | 1 |
reflectable->initializeChildren(); |
1963 |
✓✗✓✗ |
1 |
checkCompound(reflectableObject, reflectable); |
1964 |
} |
||
1965 |
|||
1966 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, compoundConstArray) |
1967 |
{ |
||
1968 |
2 |
ReflectableObject reflectableObject1; |
|
1969 |
✓✗✓✗ ✓✗ |
1 |
reflectableObject1 = createInitializedReflectableObject("1", 13); // to cover assignment operator |
1970 |
const auto rawArray = std::vector<ReflectableObject>{{ |
||
1971 |
reflectableObject1, |
||
1972 |
createInitializedReflectableObject("2", 42) |
||
1973 |
✓✗✓✗ ✓✗✓✗ ✓✓✓✗ ✗✗ |
2 |
}}; |
1974 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getCompoundArray(rawArray); |
1975 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
1976 |
2 |
[&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) { |
|
1977 |
2 |
checkCompound(value, elementReflectable); |
|
1978 |
2 |
} |
|
1979 |
✓✗ | 1 |
); |
1980 |
|||
1981 |
✓✗ | 2 |
IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1982 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(nonConstReflectable->at(0), CppRuntimeException); |
1983 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW((*nonConstReflectable)[0], CppRuntimeException); |
1984 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->resize(nonConstReflectable->size() + 1), CppRuntimeException); |
1985 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(nonConstReflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0), |
1986 |
CppRuntimeException); |
||
1987 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->append(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}})), |
1988 |
CppRuntimeException); |
||
1989 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1990 |
} |
||
1991 |
|||
1992 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, compoundArray) |
1993 |
{ |
||
1994 |
auto rawArray = std::vector<ReflectableObject>{{ |
||
1995 |
createInitializedReflectableObject("1", 13), |
||
1996 |
createInitializedReflectableObject("2", 42) |
||
1997 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✓ ✗✗ |
2 |
}}; |
1998 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getCompoundArray(rawArray); |
1999 |
2 |
checkArray(rawArray, reflectable, |
|
2000 |
2 |
[&](const ReflectableObject& value, const IReflectablePtr& elementReflectable) { |
|
2001 |
2 |
checkCompound(value, elementReflectable); |
|
2002 |
2 |
} |
|
2003 |
✓✗ | 1 |
); |
2004 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
2005 |
2 |
[&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) { |
|
2006 |
2 |
checkCompound(value, elementReflectable); |
|
2007 |
2 |
} |
|
2008 |
✓✗ | 1 |
); |
2009 |
|||
2010 |
✓✗✓✗ |
1 |
reflectable->resize(reflectable->size() + 1); |
2011 |
✓✗✓✗ ✓✗ |
2 |
IReflectablePtr newCompound = reflectable->at(reflectable->size() - 1); |
2012 |
✗✓✗✗ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_TRUE(newCompound); |
2013 |
|||
2014 |
✓✗✓✗ ✓✗ |
1 |
reflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0); |
2015 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->at(0)->find("reflectableNested.value")->getUInt32()); |
2016 |
✓✗✓✗ ✓✗ |
1 |
reflectable->append(AnyHolder<>(ReflectableObject{"test|", ReflectableNested{1}})); |
2017 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(1, reflectable->at(reflectable->size() - 1)->find("reflectableNested.value")->getUInt32()); |
2018 |
|||
2019 |
✓✗ | 1 |
const size_t size = reflectable->size(); |
2020 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(), size), CppRuntimeException); // out of range |
2021 |
} |
||
2022 |
|||
2023 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, defaultUnimplementedMethods) |
2024 |
{ |
||
2025 |
✗✓ | 1 |
class Reflectable : public ReflectableBase<std::allocator<uint8_t>> |
2026 |
{ |
||
2027 |
public: |
||
2028 |
1 |
using ReflectableBase<std::allocator<uint8_t>>::ReflectableBase; |
|
2029 |
}; |
||
2030 |
|||
2031 |
✓✗✓✗ ✓✗✗ |
2 |
Reflectable reflectable(BuiltinTypeInfo<>::getUInt8()); |
2032 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW(reflectable.bitSizeOf(0), CppRuntimeException); |
2033 |
|||
2034 |
✓✗✓✗ ✓✗✗ |
2 |
BitBuffer bitBuffer(0); |
2035 |
✓✗ | 1 |
BitStreamWriter writer(bitBuffer); |
2036 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable.write(writer), CppRuntimeException); |
2037 |
|||
2038 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable.getAnyValue(), CppRuntimeException); |
2039 |
|||
2040 |
1 |
const Reflectable& constReflectableRef = reflectable; |
|
2041 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(constReflectableRef.getAnyValue(), CppRuntimeException); |
2042 |
} |
||
2043 |
|||
2044 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST_F(ReflectableTest, reflectableOwner) |
2045 |
{ |
||
2046 |
✓✗✓✗ ✗✗ |
2 |
auto reflectable = ReflectableObject::typeInfo().createInstance(); |
2047 |
|||
2048 |
// must be as the first one to initialize object |
||
2049 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
1 |
ASSERT_NO_THROW(reflectable->initializeChildren()); |
2050 |
|||
2051 |
✓✗ | 2 |
IReflectableConstPtr constReflectable = reflectable; |
2052 |
|||
2053 |
// same as default initialized |
||
2054 |
✓✗ | 2 |
ReflectableObject defaultReflectableObject; |
2055 |
✓✗ | 1 |
defaultReflectableObject.initializeChildren(); |
2056 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(defaultReflectableObject, |
2057 |
reflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get()); |
||
2058 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(defaultReflectableObject, |
2059 |
constReflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get()); |
||
2060 |
|||
2061 |
// has no type arguments |
||
2062 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->initialize(std::vector<AnyHolder<>>()), CppRuntimeException); |
2063 |
|||
2064 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(TypeInfoUtil::isCompound(reflectable->getTypeInfo().getSchemaType())); |
2065 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(reflectable->isArray()); |
2066 |
✓✗✓✗ |
1 |
reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42})); |
2067 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(42, reflectable->getField("reflectableNested")->getField("value")->getUInt32()); |
2068 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(42, constReflectable->getField("reflectableNested")->getField("value")->getUInt32()); |
2069 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->createField("nonexistent"), CppRuntimeException); |
2070 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->getParameter("nonexistent"), CppRuntimeException); |
2071 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(constReflectable->getParameter("nonexistent"), CppRuntimeException); |
2072 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->callFunction("nonexistent"), CppRuntimeException); |
2073 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
2 |
ASSERT_THROW(constReflectable->callFunction("nonexistent"), CppRuntimeException); |
2074 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getChoice(), CppRuntimeException); |
2075 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW(constReflectable->getChoice(), CppRuntimeException); |
2076 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(reflectable->find("nonexistent")); |
2077 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(constReflectable->find("nonexistent")); |
2078 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE((*reflectable)["nonexistent"]); |
2079 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗ |
1 |
ASSERT_FALSE((*constReflectable)["nonexistent"]); |
2080 |
|||
2081 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->size(), CppRuntimeException); // not an array |
2082 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->resize(0), CppRuntimeException); // not an array |
2083 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->at(0), CppRuntimeException); // not an array |
2084 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(constReflectable->at(0), CppRuntimeException); // not an array |
2085 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW((*reflectable)[0], CppRuntimeException); // not an array |
2086 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW((*constReflectable)[0], CppRuntimeException); // not an array |
2087 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException); // not an array |
2088 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
2 |
ASSERT_THROW(reflectable->append(AnyHolder<>()), CppRuntimeException); // not an array |
2089 |
|||
2090 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getBool(), CppRuntimeException); |
2091 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
2092 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
2093 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
2094 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
2095 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
2096 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
2097 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
2098 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
2099 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
2100 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
2101 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
2102 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
2103 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
2104 |
|||
2105 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
2106 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
2107 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
2108 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
2109 |
|||
2110 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✗ |
1 |
ASSERT_EQ(reflectable->bitSizeOf(), reflectable->initializeOffsets()); |
2111 |
|||
2112 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
1 |
ASSERT_NO_THROW(reflectable->initializeChildren()); |
2113 |
|||
2114 |
✓✗ | 1 |
const size_t bitSizeOfValue = reflectable->bitSizeOf(); |
2115 |
✓✗✓✗ |
2 |
BitBuffer bitBuffer(bitSizeOfValue); |
2116 |
✓✗ | 1 |
BitStreamWriter writer(bitBuffer); |
2117 |
✓✗ | 1 |
reflectable->write(writer); |
2118 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(bitSizeOfValue, writer.getBitPosition()); |
2119 |
} |
||
2120 |
|||
2121 |
✓✗✓✗ |
2394 |
} // namespace zserio |
| Generated by: GCOVR (Version 4.2) |